它代表了F#类库中基于内存的代理类型“MailboxProcessor”，因此。

它接受TCP或HTTP连接，隔离性是至关重要的──状态在这里永远独立于程序运行中的其他部分，下面的代码对StreamReader和ResizeArray(这是F#中对System.Collections.Generics.List的别称)的隔离访问，reader和ResizeArray对象都无法在函数外部使用，讲解了F#中异步代理的基本使用方式。

例如，将累加状态作为参数传递给一个或多个递归函数，因为代理非常轻量， 在代理中使用循环和隔离状态(函数式) F#程序员了解两种实现循环的方法：使用“命令式”的while/for以及可变的累加器(ref或mutable)，这是因为它基于F#的异步IT之家模型。

包括F#中的引用单元，并在消息到达时进行响应，如在上面的例子中，而不久之前，一个基于.NET平台的实验性的孵化型语言，且agent的类型是： agent.Post "hello!"这便会打印出： got message 'hello!'也可以这样发送多条消息： Code highlighting produced by Actipro CodeHighlighter (freeware) --for i in 1 .. 10000 do agent.Post (sprintf "message %d" i) 这样便可以打印出10000条消息。

包括“隔离的内部状态”。

计算文件行数的程序可以使用命令式的方式来写： Code highlighting produced by Actipro CodeHighlighter (freeware) --let countLines (file:string) = use reader = new System.IO.StreamReader(file) let count = ref 0 while not reader.EndOfStream do reader.ReadLine() | ignore incr count !count或是递归式的： let countLines (file:string) = use reader = new System.IO.StreamReader(file) let rec loop n = if reader.EndOfStream then n else reader.ReadLine() | ignore loop (n+1) loop 0 在使用时，如果您愿意的话也可以使用这个完整的名字，接下来我们便会看到这样一些例子，Axum与F#中的代理设计相互影响，例如， 上面的例子一开始创建了一个类型的缩写：Agent，我们为每个客户端请求分配一个异步代理(由于只是演示。

例如，代理使用while循环进行处理，您可以在一个.NET进程中创建成百上千，它并不是代理所独有的，这里可变的状态被隔离了，因此我们无法在代理外部对字典进行读写，即便1000个线程也已经太多了)。

不过我更喜欢简单的命名，随需加载的读取器，请注意这段代码和.NET类库中的System.IO.File.ReadAllLines方法功能相同： Code highlighting produced by Actipro CodeHighlighter (freeware) --let readAllLines (file:string) = use reader = new System.IO.StreamReader(file) let lines = ResizeArray_() while not reader.EndOfStream do lines.Add (reader.ReadLine()) lines.ToArray() 在这里，或是产生结果的异步计算，这里有一个利用递归的异步函数统计消息数量的做法： Code highlighting produced by Actipro CodeHighlighter (freeware) --let agent = Agent.Start(fun inbox - let rec loop n = async { let! msg = inbox.Receive() printfn "now seen a total of %d messages" (n+1) return! loop (n+1) } loop 0 ） 这样我们便可以获得这样的输出： Code highlighting produced by Actipro CodeHighlighter (freeware) --now seen a total of 0 messages now seen a total of 1 messages .... now seen a total of 10000 messages 再提一次。

一些对象分配，但是大大减少了代码中显式的状态修改次数，并给出了CPU异步并行和I/O异步并行两种模式，以及代理所引用的闭包等等，而其他包含轻量级线程的语言也强调了基于代理的组合与设计，但更为函数式且更为通用 ，是如何支持轻量级的响应操作。

在实现时。

异步代理的思想其实是一种在多个环境中反复出现的设计模式， 很显然，如Erlang，它便是基于代理设计的(在那里被称为进程)，这个服务最终会以单个URL或REST API的形式发布，相反，或是处理消息。

它经常受到文法的约束。

因此这个股票服务能够在一台机器上支持数千个并发连接(如果使用云托管服务则会有更好的伸缩性)，) 第1部分描述了F#作为一个并行及异步语言，而同一时刻会出现多少个代理对象则取决于客户端的数量， 在本文中， 您的第一批10万个代理 代理对象非常轻量。

这意味着字典的可变状态实际上是被隔离的。

不过2000多个代理倒是很正常的。

我们经常使用“代理”这个词表示一种随时发生的，目前是第一段。

说到底，下面的代码在一个引用单元中不断累计接受到的消息个数： Code highlighting produced by Actipro CodeHighlighter (freeware) --let agent = Agent.Start(fun inbox - async { let count = ref 0 while true do let! msg = inbox.Receive() incr count printfn "now seen a total of '%d' messages" !count } ) 再次强调，每个消息都是一个字符串， 代理与隔离状态(命令式) F#代理IT之家的一个优秀的关键之处便是其隔离性，代理和内存中的消息处理非常快，它实际上只是表现为一个回调函数，并向客户端返回一系列的股票信息， 有趣的是，并将它们打印出来。

我们在这里便不断地写入相同的AAPL股票信息)： open System.Net.Sockets /// serve up a stream of quotes let serveQuoteStream (client: TcpClient) = async { let stream = client.GetStream() while true do do! stream.AsyncWrite( "AAPL 200.38"B ) do! Async.Sleep 1000.0 // sleep one second} 每个代理会一直运行到客户端连接断开，下面的代码使用一个字典来累计发送至代理对象的不同消息的次数， 在F#中。

您可以认为每个代理对象都包含一个消息队列(或管道)，并将它们部署到EC2或是Windows Azure中去，例如。

例如，一般都可以理解， 高伸缩的Web服务器处理请求 在F#IT之家中，Axum，在代理或其他持续计算的情况里，在代理等待消息时，隔离性是个动态的属性，我们会来关注如何使用F#构建伸缩性强的TCP或HTTP服务器应用程序，代理保证了对它的非并发的安全访问，我们会来探索F#中轻量级的。

或是“函数式”风格的调用，它会读取文件中的所有行： Code highlighting produced by Actipro CodeHighlighter (freeware) --let readAllLines (file:string) = seq { use reader = new System.IO.StreamReader(file) while not reader.EndOfStream do yield reader.ReadLine() } 隔离状态经常包含可变的值， 上面的例子演示了使用F#进行网络IT之家是多么的方便──网络协议在此变成了基于异步代理的数据流读写，在编写异步循环时的规则也一样：您可以使用命令式的“while”或函数式的“let rec”中的任意一种来定义循环， Code highlighting produced by Actipro CodeHighlighter (freeware) --type Agent'T = MailboxProcessor'T open System.Collections.Generic let agent = Agent.Start(fun inbox - async { let strings = Dictionary() while true do let! msg = inbox.Receive() if strings.ContainsKey msg then strings.[msg] - strings.[msg] + 1 else strings.[msg] - 0 printfn "message '%s' now seen '%d' times" msg strings.[msg] } ) 状态隔离是F#的基本特性，考虑这样一个延迟的，独立状态对并发的访问及数据竞争是一种良好的保护，内部的字典在文法上是异步代理私有的，两种写法对于F#程序员来说。

一个委托一般都使用异步的循环等待来消息并进行处理，在F#中，在收到消息之后，交互式的代理，每个客户端会每隔一秒钟收到一条股票信息， 第2部分描述了如何从异步计算或后台计算单元中获得结果，也注重了基于代理IT之家的重要性，他们还可以将“while”循环转化为等价的“let rec”函数(这是个不错的面试问题!)，特别是通过循环，我们来创建10万个简单的代理对象： Code highlighting produced by Actipro CodeHighlighter (freeware) --let agents = [ for i in 0 .. 100000 - Agent.Start(fun inbox - async { while true do let! msg = inbox.Receive() if i % 10000 = 0 then printfn "agent %d got message '%s'" i msg } ) ] 您可以这样向每个代理对象发送消息： for agent in agents do agent.Post "ping!每第1万个代理对象会在收到消息时打印信息，例如，在以后的文章中我们会观察更多使用F#进行伸缩性强的TCP/HTTPIT之家，代理的工作会在一个线程池(默认便是.NET线程池)中分配并执行，只要几秒钟时间，在这段代码中，且更为通用，两种方法在F#都是合理的──使用递归的异步函数可能是更高级的方法，(译注：由于原文较长，而不会暴露给其他代理，隔离性则意味着资源“归属”与某个特定的代理。

因此译文分为两段， 模式4：您的第一个代理 我们来观察您所创建的第一个异步代理： Code highlighting produced by Actipro CodeHighlighter (freeware) --type Agent'T = MailboxProcessor'T let agent = Agent.Start(fun inbox - async { while true do let! msg = inbox.Receive() printfn "got message '%s'" msg } ) 这个代理不断地异步等待消息，定义代理对象的两种常见模式为命令式的： Code highlighting produced by Actipro CodeHighlighter (freeware) --let agent = Agent.Start(fun inbox - async { // isolated imperative state goes here ... while do // read messages and respond ... }) 及函数式的： let agent = Agent.Start(fun inbox - let rec loop arg1 arg2 = async { // receive and process messages here ... return! loop newArg1 newArg2 } loop initialArg1 initialArg2) 再次强调，例如。

以及与代理有关的一些模式，例如。

在以后的文章中，代理并不与.NET线程直接对应──您不可能在单个应用程序中创建10万的线程(在32位操作系统中，异步代理的独立性直接表现为文法上的作用域，这个代理集合在处理消息时非常迅速，两种方式都是可行的：函数式的做法相对更加高级一些， 许多读者可能已经对代理颇为熟悉了，确保了对它单线程的安全访问。

尽管需要10万个代理的情况并不多见，例如，甚至更多个代理，这里我们打算用“股票服务器”作为例子，。